home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 April: Mac OS SDK / Dev.CD Apr 00 SDK1.toast / Development Kits / Hardware / PC Card SDKs / PC Card Manager 3.0 / CIncludes / PCCard.h < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-05  |  20.6 KB  |  474 lines  |  [TEXT/MPS ]
  1. /*
  2.      File:        PCCard.h
  3.  
  4.      Contains:    PC Card Family Programming interface
  5.  
  6.      Version:    System 7.5 and System 8
  7.  
  8.      DRI:        Dave Falkenburg
  9.  
  10.      Copyright:    © 1984-1996 by Apple Computer, Inc.
  11.                  All rights reserved.
  12.  
  13.      Warning:    *** APPLE INTERNAL USE ONLY ***
  14.                  This file may contain unreleased API's
  15.  
  16.      BuildInfo:    Built by:            Dave Falkenburg
  17.                  With Interfacer:    2.0d13   (PowerPC native)
  18.                  From:                PCCard.i
  19.                      Revision:        28*
  20.                      Dated:            12/12/96
  21.                      Last change by:    DRF
  22.                      Last comment:    RegEntryRef -> RegEntryID
  23.  
  24.      Bugs:        Report bugs to Radar component “System Interfaces”, “Latest”
  25.                  List the version information (from above) in the Problem Description.
  26.  
  27. */
  28. #ifndef __PCCARD__
  29. #define __PCCARD__
  30.  
  31. #ifndef __TYPES__
  32. #include <Types.h>
  33. #endif
  34. #ifndef __NAMEREGISTRY__
  35. #include <NameRegistry.h>
  36. #endif
  37.  
  38. #ifdef __cplusplus
  39. extern "C" {
  40. #endif
  41.  
  42. #if PRAGMA_IMPORT_SUPPORTED
  43. #pragma import on
  44. #endif
  45.  
  46. #if PRAGMA_ALIGN_SUPPORTED
  47. #pragma options align=power
  48. /* the following contents can only be used by compilers that support PowerPC struct alignment */
  49.  
  50. /*    Copyright:    © 1996 SystemSoft Corporation, all rights reserved. */
  51.  
  52. enum {
  53.     kServiceCategoryPCCard        = 'pccd'
  54. };
  55.  
  56.  
  57. enum {
  58.     gestaltPCCard                = 'pccd',
  59.     gestaltPCCardDispatchExists    = 0,                            /* if set, 68K support is present*/
  60.     gestaltPCCardFamilyPresent    = 1                                /* if set, PowerPC API is present*/
  61. };
  62.  
  63. typedef UInt32 PCCardEvent;
  64. typedef UInt32 PCCardEventMask;
  65. typedef UInt32 PCCardClientID;
  66. typedef UInt32 PCCardTimerID;
  67. typedef UInt32 PCCardSocket;
  68. typedef UInt32 PCCardWindowID;
  69. typedef UInt32 PCCardWindowType;
  70. typedef UInt32 PCCardWindowSize;
  71. typedef UInt32 PCCardWindowOffset;
  72. typedef UInt32 PCCardWindowAlign;
  73. typedef OptionBits PCCardWindowState;
  74. typedef UInt32 PCCardAccessSpeed;
  75. typedef UInt32 PCCardPage;
  76. typedef UInt32 PCCardVoltage;
  77. /* Client notification bit flags */
  78.  
  79. enum {
  80.     kPCCardNullMessage            = 0x00000000,                    /* no messages pending (not sent to clients)*/
  81.     kPCCardInsertionMessage        = 0x00000001,                    /* card has been inserted into the socket*/
  82.     kPCCardRemovalMessage        = 0x00000002,                    /* card has been removed from the socket- do not touch hardware!*/
  83.     kPCCardLockMessage            = 0x00000004,                    /* card is locked into the socket with a mechanical latch*/
  84.     kPCCardUnlockMessage        = 0x00000008,                    /* card is no longer locked into the socket*/
  85.     kPCCardReadyMessage            = 0x00000010,                    /* card is ready to be accessed*/
  86.     kPCCardResetMessage            = 0x00000020,                    /* physical reset has completed*/
  87.     kPCCardInsertionRequestMessage = 0x00000040,                /* request to insert a card using insertion motor*/
  88.     kPCCardInsertionCompleteMessage = 0x00000080,                /* insertion motor has finished inserting a card*/
  89.     kPCCardEjectionRequestMessage = 0x00000100,                    /* user or other client is requesting a card ejection*/
  90.     kPCCardEjectionCompleteMessage = 0x00000200,                /* card ejection succeeded- do not touch hardware! */
  91.     kPCCardEjectionFailedMessage = 0x00000400,                    /* eject failure due to electrical/mechanical problems*/
  92.     kPCCardPMResumeMessage        = 0x00000800,                    /* power management resume (TBD)*/
  93.     kPCCardPMSuspendMessage        = 0x00001000,                    /* power management suspend (TBD)*/
  94.     kPCCardPMSuspendRequest        = 0x00002000,                    /* power management sleep request (TBD)*/
  95.     kPCCardPMSuspendRevoke        = 0x00004000,                    /* power management sleep revoke  (TBD)*/
  96.     kPCCardResetPhysicalMessage    = 0x00008000,                    /* physical reset is about to occur on this card*/
  97.     kPCCardResetRequestMessage    = 0x00010000,                    /* physical reset has been requested by a client*/
  98.     kPCCardResetCompleteMessage    = 0x00020000,                    /* ResetCard() background reset has completed*/
  99.     kPCCardBatteryDeadMessage    = 0x00040000,                    /* battery is no longer useable, data will be lost*/
  100.     kPCCardBatteryLowMessage    = 0x00080000,                    /* battery is weak and should be replaced*/
  101.     kPCCardWriteProtectMessage    = 0x00100000,                    /* card is now write protected*/
  102.     kPCCardWriteEnabledMessage    = 0x00200000,                    /* card is now write enabled*/
  103.     kPCCardClientInfoMessage    = 0x00400000,                    /* client is to return client information*/
  104.     kPCCardSSUpdatedMessage        = 0x00800000,                    /* AddSocketServices/ReplaceSocket services has changed SS support*/
  105.     kPCCardFunctionInterruptMessage = 0x01000000,                /* card function interrupt*/
  106.     kPCCardAccessErrorMessage    = 0x02000000,                    /* client bus errored on access to socket*/
  107.     kPCCardUnconfiguredMessage    = 0x04000000,                    /* a CARD_READY was delivered to all clients and no client */
  108.                                                                 /*    requested a configuration for the socket*/
  109.     kPCCardStatusChangedMessage    = 0x08000000,                    /* status change for cards in I/O mode*/
  110.     kPCCardTimerExpiredMessage    = 0x10000000,                    /* message sent when requested time has expired */
  111.     kPCCardRequestAttentionMessage = 0x20000000,
  112.     kPCCardEraseCompleteMessage    = 0x40000000,
  113.     kPCCardRegistrationCompleteMessage = 0x80000000
  114. };
  115.  
  116. typedef OptionBits PCCardWindowAttributes;
  117. /*    window state (values of PCCardWindowAttributes) */
  118.  
  119. enum {
  120.     kWSCommon                    = 0x0001,                        /* common memory window */
  121.     kWSAttribute                = 0x0002,                        /* attribute memory window*/
  122.     kWSIO                        = 0x0004,                        /* I/O window*/
  123.     kWSTypeMask                    = 0x0007,                        /* window type mask*/
  124.     kWSEnabled                    = 0x0008,                        /* window enabled*/
  125.     kWS8bit                        = 0x0010,                        /* 8-bit data width window*/
  126.     kWS16bit                    = 0x0020,                        /* 16-bit data width window*/
  127.     kWS32bit                    = 0x0040,                        /* 32-bit data width window*/
  128.     kWSAutoSize                    = 0x0080,                        /* auto-size data width window*/
  129.     kWSWidthMask                = 0x00F0,                        /* window data width mask*/
  130.     kWSProtected                = 0x0100,                        /* window write protected*/
  131.     kWSPrefetchable                = 0x0200,                        /* bridge window prefetchable*/
  132.     kWSPageShared                = 0x0400,                        /* page register is shared*/
  133.     kWSWindowSizeOffset            = 0x4000,
  134.     kWSChangeAccessSpeed        = 0x8000                        /* Used by CSModifyWindow only */
  135. };
  136.  
  137. typedef UInt32 PCCardInterfaceType;
  138. /* InterfaceType bit-mask (values of PCCardInterfaceType) */
  139.  
  140. enum {
  141.     kIFTypeMask                    = 0x03,                            /* IO & memory type mask*/
  142.     kIFCardBus                    = 0x00,                            /* if bits 0 & 1 are zero then cardbus interface*/
  143.     kIFMemory                    = 0x01,                            /* if bit 0 set memory IF*/
  144.     kIFIO                        = 0x02,                            /* if bit 1 set IO IF*/
  145.     kIFReserved                    = 0x03,                            /* bits 0 and 1 set is reserved */
  146.     kIFDMA                        = 0x08,                            /* if bit 3 set DMA supported*/
  147.     kIFVSKey                    = 0x10,                            /* if bit 4 set supports low Voltage key*/
  148.     kIF33VCC                    = 0x20,                            /* if bit 5 set socket suports 3.3v*/
  149.     kIFXXVCC                    = 0x40,                            /* if bit 6 set socket supports X.X voltage*/
  150.     kIFYYVCC                    = 0x80                            /* if bit 7 set socket supports Y.Y voltage*/
  151. };
  152.  
  153. typedef UInt32 PCCardCustomInterfaceID;
  154. /* Custom Interface Identifiers (values of PCCardCustomInterfaceID) */
  155.  
  156. enum {
  157.     kIFCustom_None                = 0x00,                            /* no custom interface ID */
  158.     kIFCustom_ZOOM                = 0x41                            /* ZOOM Video Mode custom interface identifier */
  159. };
  160.  
  161. typedef OptionBits PCCardConfigOptions;
  162. /* Bit mask values for PCCardConfigOptions in the configuration calls */
  163.  
  164. enum {
  165.     kEnableIRQSteering            = 0x0002,
  166.     kIRQChangeValid                = 0x0004,
  167.     kVppChangeValid                = 0x0010,
  168.     kEnableDMAChannel            = 0x0040,
  169.     kDMAChangeValid                = 0x0080,
  170.     kVSOverride                    = 0x0200                        /* Bits 10..31 reserved */
  171. };
  172.  
  173. typedef UInt32 PCCardConfigPresentMask;
  174. typedef UInt32 PCCardConfigRegisterIndex;
  175. typedef UInt32 PCCardConfigRegisterOffset;
  176. struct PCCardFunctionConfigReg {
  177.     Byte                             configOptionReg;
  178.     Byte                             configStatusReg;
  179.     Byte                             pinReplaceReg;
  180.     Byte                             socketCopyReg;
  181.     Byte                             extendedStatusReg;
  182.     Byte                             ioBase0;
  183.     Byte                             ioBase1;
  184.     Byte                             ioBase2;
  185.     Byte                             ioBase3;
  186.     Byte                             ioLimit;
  187. };
  188. typedef struct PCCardFunctionConfigReg PCCardFunctionConfigReg;
  189.  
  190. typedef OptionBits PCCardSocketStatus;
  191. /*    general socket status bits (values of PCCardSocketStatus) */
  192.  
  193. enum {
  194.     kSTBatteryDead                = 0x0001,                        /* battery dead*/
  195.     kSTBatteryLow                = 0x0002,                        /* battery low*/
  196.     kSTBatteryGood                = 0x0004,                        /* battery good*/
  197.     kSTPower                    = 0x0008,                        /* power is applied*/
  198.     kST16bit                    = 0x0010,                        /* 16-bit PC Card present*/
  199.     kSTCardBus                    = 0x0020,                        /* CardBus PC Card present*/
  200.     kSTMemoryCard                = 0x0040,                        /* memory card present*/
  201.     kSTIOCard                    = 0x0080,                        /* I/O card present*/
  202.     kSTNotACard                    = 0x0100,                        /* unrecognizable PC Card detected*/
  203.     kSTReady                    = 0x0200,                        /* ready*/
  204.     kSTWriteProtect                = 0x0400,                        /* card is write-protected*/
  205.     kSTDataLost                    = 0x0800,                        /* data may have been lost due to card removal*/
  206.     kSTRingIndicate                = 0x1000,                        /* ring indicator is active*/
  207.     kSTReserved                    = 0xE000
  208. };
  209.  
  210. /* Bit mask for PCCardPowerOptions in the power management calls */
  211. typedef OptionBits PCCardPowerOptions;
  212.  
  213. enum {
  214.     kPCCardPowerOn                = 0x00000001,
  215.     kPCCardPowerOff                = 0x00000002,
  216.     kPCCardLowPower                = 0x00000004
  217. };
  218.  
  219. typedef OptionBits PCCardAdapterCapabilities;
  220. typedef UInt32 PCCardAdapterPowerState;
  221. typedef OptionBits PCCardSCEvents;
  222. typedef UInt32 PCCardWindow;
  223. typedef UInt32 PCCardIRQ;
  224. typedef UInt32 PCCardDMA;
  225. /* Types and structures for accessing the PCCard Assigned-Address property.*/
  226. #define kPCCardAssignedAddressProperty "assigned-addresses"
  227.  
  228. enum {
  229.     kPCCardNonRelocatableSpace    = 0x80,
  230.     kPCCardPrefetchableSpace    = 0x40,
  231.     kPCCard16BitSpace            = 0x20,
  232.     kPCCardAddressTypeCodeMask    = 0x07,
  233.     kPCCardConfigSpace            = 0,
  234.     kPCCardIOSpace                = 1,
  235.     kPCCardMemorySpace            = 2,
  236.     kPCCardAttributeMemorySpace    = 4
  237. };
  238.  
  239. typedef UInt8 PCCardAddressSpaceFlags;
  240.  
  241. enum {
  242.     kPCCardSocketNumberMask        = 0xF8,
  243.     kPCCardFunctionNumberMask    = 0x07
  244. };
  245.  
  246. typedef UInt8 PCCardSocketFunction;
  247. typedef UInt8 PCCardBusNumber;
  248. typedef UInt8 PCCardRegisterNumber;
  249. struct PCCardAssignedAddress {
  250.     PCCardAddressSpaceFlags         addressSpaceFlags;
  251.     UInt8                             reserved;
  252.     PCCardSocketFunction             socketFunctionNumber;
  253.     PCCardRegisterNumber             registerNumber;
  254.     UInt32                             address;
  255.     UInt32                             size;
  256. };
  257. typedef struct PCCardAssignedAddress PCCardAssignedAddress;
  258.  
  259. typedef PCCardAssignedAddress *PCCardAssignedAddressPtr;
  260. #define GetPCCardIsNonRelocatable( AssignedAddressPtr )        ((AssignedAddressPtr)->addressSpaceFlags & kPCCardNonRelocatableSpace)
  261. #define GetPCCardIsPrefetchable( AssignedAddressPtr )        ((AssignedAddressPtr)->addressSpaceFlags & kPCCardPrefetchableSpace)
  262. #define GetPCCardIs16BitSpace( AssignedAddressPtr )            ((AssignedAddressPtr)->addressSpaceFlags & kPCCard16BitSpace)
  263. #define GetPCCardAddressSpaceType( AssignedAddressPtr )        ((AssignedAddressPtr)->addressSpaceFlags & kPCCardAddressTypeCodeMask)
  264. #define GetPCCardSocketNumber( AssignedAddressPtr )            (((AssignedAddressPtr)->socketFunctionNumber >> 3) & kPCCardSocketNumberMask)
  265. #define GetPCCardFunctionNumber( AssignedAddressPtr )        ((AssignedAddressPtr)->socketFunctionNumber & kPCCardFunctionNumberMask)
  266. #define GetPCCardRegisterNumber( AssignedAddressPtr )        ((AssignedAddressPtr)->registerNumber)
  267. /*
  268. ----------------------------------------------------------------------
  269.     Client Support
  270. ----------------------------------------------------------------------
  271. */
  272. /* Prototype for client callback */
  273. typedef OSStatus (*PCCardEventHandler)(PCCardEvent theEvent, PCCardSocket vSocket, UInt32 device, UInt32 info, UInt32 MTDRequest, UInt32 *Buffer, UInt32 misc, UInt32 status, void *clientParam);
  274. extern OSStatus PCCardRegisterClient(const RegEntryID *deviceRef, PCCardEventMask eventMask, PCCardEventHandler clientCallBack, void *clientParam, PCCardClientID *newClientID);
  275.  
  276. extern OSStatus PCCardDeRegisterClient(PCCardClientID theClientID);
  277.  
  278. extern OSStatus PCCardRegisterTimer(PCCardClientID registeredClientID, PCCardTimerID *lpNewTimerID, long delay);
  279.  
  280. extern void PCCardDeRegisterTimer(PCCardTimerID timerID);
  281.  
  282. extern OSStatus PCCardSetEventMask(PCCardClientID theClientID, PCCardEventMask newEventMask);
  283.  
  284. extern OSStatus PCCardGetEventMask(PCCardClientID theClientID, PCCardEventMask *newEventMask);
  285.  
  286. extern OSStatus PCCardGetCardServicesInfo(ItemCount *socketCount, UInt32 *complianceLevel, UInt32 *version);
  287.  
  288. extern OSStatus PCCardGetSocketRef(PCCardSocket vSocket, RegEntryID *socketRef);
  289.  
  290. extern OSStatus PCCardGetCardRef(PCCardSocket vSocket, RegEntryID *cardRef);
  291.  
  292. extern OSStatus PCCardGetSocketAndDeviceFromDeviceRef(const RegEntryID *deviceRef, PCCardSocket *vSocket, UInt32 *device);
  293.  
  294. extern OSStatus PCCardGetCardRefFromDeviceRef(const RegEntryID *deviceRef, RegEntryID *cardRef);
  295.  
  296. /*
  297. ----------------------------------------------------------------------
  298.     Resource Management
  299. ----------------------------------------------------------------------
  300. */
  301. extern OSStatus PCCardRequestWindow(const RegEntryID *deviceRef, PCCardWindowAttributes windowAttributes, LogicalAddress *windowBase, ByteCount *windowSize, PCCardAccessSpeed *windowSpeed, PCCardWindowOffset *windowOffset, PCCardWindowID *windowID);
  302.  
  303. extern OSStatus PCCardModifyWindow(PCCardWindowID windowID, PCCardWindowAttributes windowAttributes, PCCardAccessSpeed windowSpeed, PCCardWindowOffset windowOffset);
  304.  
  305. extern OSStatus PCCardReleaseWindow(PCCardWindowID windowID);
  306.  
  307. extern OSStatus PCCardGetStatus(const RegEntryID *deviceRef, UInt32 *currentState, UInt32 *changedState, PCCardVoltage *Vcc, PCCardVoltage *Vpp);
  308.  
  309. extern OSStatus PCCardRequestConfiguration(const RegEntryID *deviceRef, PCCardConfigOptions configOptions, PCCardInterfaceType ifType, PCCardCustomInterfaceID ifCustomType, PCCardVoltage vcc, PCCardVoltage vpp, LogicalAddress configRegistersBase, PCCardConfigPresentMask configRegistersPresent, PCCardFunctionConfigReg *configRegisterValues);
  310.  
  311. extern OSStatus PCCardReleaseConfiguration(const RegEntryID *deviceRef);
  312.  
  313. extern OSStatus PCCardModifyConfiguration(const RegEntryID *deviceRef, PCCardConfigOptions configOptions, PCCardVoltage vpp);
  314.  
  315. extern OSStatus PCCardReadConfigurationRegister(const RegEntryID *deviceRef, PCCardConfigRegisterIndex whichRegister, PCCardConfigRegisterOffset offset, UInt8 *value);
  316.  
  317. extern OSStatus PCCardWriteConfigurationRegister(const RegEntryID *deviceRef, PCCardConfigRegisterIndex whichRegister, PCCardConfigRegisterOffset offset, UInt8 value);
  318.  
  319. extern OSStatus PCCardResetFunction(const RegEntryID *deviceRef);
  320.  
  321. /*
  322. ----------------------------------------------------------------------
  323.     Client Utilities
  324. ----------------------------------------------------------------------
  325. */
  326. typedef UInt8 PCCardTupleKind;
  327. typedef struct OpaquePCCardTupleIterator* PCCardTupleIterator;
  328. extern PCCardTupleIterator PCCardNewTupleIterator(void );
  329.  
  330. extern OSStatus PCCardDisposeTupleIterator(PCCardTupleIterator tupleIterator);
  331.  
  332. extern OSStatus PCCardGetFirstTuple(const RegEntryID *deviceID, PCCardTupleKind desiredTuple, PCCardTupleIterator tupleIterator, void *dataBuffer, UInt32 *dataBufferSize, PCCardTupleKind *foundTuple, UInt32 *foundTupleDataSize);
  333.  
  334. extern OSStatus PCCardGetNextTuple(const RegEntryID *deviceRef, PCCardTupleKind desiredTuple, PCCardTupleIterator tupleIterator, void *dataBuffer, UInt32 *dataBufferSize, PCCardTupleKind *foundTuple, UInt32 *foundTupleDataSize);
  335.  
  336. /*
  337. ----------------------------------------------------------------------
  338.     Miscellaneous
  339. ----------------------------------------------------------------------
  340. */
  341. extern OSStatus PCCardEject(const RegEntryID *cardRef);
  342.  
  343. extern OSStatus PCCardEnableModemSound(const RegEntryID *cardRef, Boolean enableSound);
  344.  
  345. extern OSStatus PCCardEnableZoomedVideoSound(const RegEntryID *cardRef, Boolean enableSound);
  346.  
  347. typedef UInt32 PCCardDevType;
  348. typedef UInt32 PCCardSubType;
  349. /* values for PCCardType and PCCardSubType*/
  350.  
  351. enum {
  352.     kPCCardUnknownType            = 0,
  353.     kPCCardMultiFunctionType    = 1,
  354.     kPCCardMemoryType            = 2,
  355.     kPCCardNullSubType            = 0,                            /* Memory sub types */
  356.     kPCCardRomSubType            = 1,
  357.     kPCCardOTPromSubType        = 2,
  358.     kPCCardEpromSubType            = 3,
  359.     kPCCardEEpromSubType        = 4,
  360.     kPCCardFlashSubType            = 5,
  361.     kPCCardSramSubType            = 6,
  362.     kPCCardDramSubType            = 7,
  363.     kPCCardSerialPortType        = 3,
  364.     kPCCardSerialOnlySubType    = 0,
  365.     kPCCardDataModemSubType        = 1,
  366.     kPCCardFaxModemSubType        = 2,
  367.     kPCCardFaxAndDataModemMask    = (kPCCardDataModemSubType | kPCCardFaxModemSubType),
  368.     kPCCardVoiceEncodingSubType    = 4,
  369.     kPCCardParallelPortType        = 4,
  370.     kPCCardFixedDiskType        = 5,
  371.     kPCCardUnknownFixedDiskType    = 0,
  372.     kPCCardATAInterfaceDiskSubType = 1,
  373.     kPCCardRotatingDeviceSubType = (0 << 7),
  374.     kPCCardSiliconDevice        = (1 << 7),
  375.     kPCCardVideoAdaptorType        = 6,
  376.     kPCCardNetworkAdaptorType    = 7,
  377.     kPCCardArcNetSubType        = 1,                            /* network sub types */
  378.     kPCCardEthernetSubType        = 2,
  379.     kPCCardTokenRingSubType        = 3,
  380.     kPCCardLocalTalkSubType        = 4,
  381.     kPCCardFDDI_CDDISubType        = 5,
  382.     kPCCardATMSubType            = 6,
  383.     kPCCardWirelessSubType        = 7,
  384.     kPCCardAIMSType                = 8,
  385.     kPCCardSCSIType                = 9
  386. };
  387.  
  388. extern OSStatus PCCardGetCardInfo(const RegEntryID *cardRef, PCCardDevType *cardType, PCCardSubType *cardSubType, StringPtr cardName, StringPtr vendorName);
  389.  
  390.  
  391. enum {
  392.     kPCCard16HardwareType        = 'pc16',
  393.     kCardBusHardwareType        = 'cdbs'
  394. };
  395.  
  396. typedef UInt32 PCCardHardwareType;
  397. /* error codes */
  398.  
  399. enum {
  400.     kBadAdapterErr                = -9050,                        /* invalid adapter number*/
  401.     kBadAttributeErr            = -9051,                        /* specified attributes field value is invalid*/
  402.     kBadBaseErr                    = -9052,                        /* specified base system memory address is invalid*/
  403.     kBadEDCErr                    = -9053,                        /* specified EDC generator specified is invalid*/
  404.     kBadIRQErr                    = -9054,                        /* specified IRQ level is invalid*/
  405.     kBadOffsetErr                = -9055,                        /* specified PC card memory array offset is invalid*/
  406.     kBadPageErr                    = -9056,                        /* specified page is invalid*/
  407.     kBadSizeErr                    = -9057,                        /* specified size is invalid*/
  408.     kBadSocketErr                = -9058,                        /* specified logical or physical socket number is invalid*/
  409.     kBadTypeErr                    = -9059,                        /* specified window or interface type is invalid*/
  410.     kBadVccErr                    = -9060,                        /* specified Vcc power level index is invalid*/
  411.     kBadVppErr                    = -9061,                        /* specified Vpp1 or Vpp2 power level index is invalid*/
  412.     kBadWindowErr                = -9062,                        /* specified window is invalid*/
  413.     kBadArgLengthErr            = -9063,                        /* ArgLength argument is invalid*/
  414.     kBadArgsErr                    = -9064,                        /* values in argument packet are invalid*/
  415.     kBadHandleErr                = -9065,                        /* clientHandle is invalid*/
  416.     kBadCISErr                    = -9066,                        /* CIS on card is invalid*/
  417.     kBadSpeedErr                = -9067,                        /* specified speed is unavailable*/
  418.     kReadFailureErr                = -9068,                        /* unable to complete read request*/
  419.     kWriteFailureErr            = -9069,                        /* unable to complete write request*/
  420.     kGeneralFailureErr            = -9070,                        /* an undefined error has occurred*/
  421.     kNoCardErr                    = -9071,                        /* no PC card in the socket*/
  422.     kUnsupportedFunctionErr        = -9072,                        /* function is not supported by this implementation*/
  423.     kUnsupportedModeErr            = -9073,                        /* mode is not supported*/
  424.     kBusyErr                    = -9074,                        /* unable to process request at this time - try later*/
  425.     kWriteProtectedErr            = -9075,                        /* media is write-protected*/
  426.     kConfigurationLockedErr        = -9076,                        /* a configuration has already been locked*/
  427.     kInUseErr                    = -9077,                        /* requested resource is being used by a client*/
  428.     kNoMoreItemsErr                = -9078,                        /* there are no more of the requested item*/
  429.     kOutOfResourceErr            = -9079,                        /* Card Services has exhausted the resource*/
  430.     kNoCardSevicesSocketsErr    = -9080,
  431.     kInvalidRegEntryErr            = -9081,
  432.     kBadLinkErr                    = -9082,
  433.     kBadDeviceErr                = -9083,
  434.     k16BitCardErr                = -9084,
  435.     kCardBusCardErr                = -9085,
  436.     kPassCallToChainErr            = -9086,
  437.     kCantConfigureCardErr        = -9087,
  438.     kPostCardEventErr            = -9088,                        /* _PCCSLPostCardEvent failed and dropped an event */
  439.     kInvalidDeviceNumber        = -9089,
  440.     kUnsupportedVsErr            = -9090,                        /* Unsupported Voltage Sense */
  441.     kInvalidCSClientErr            = -9091,                        /* Card Services ClientID is not registered */
  442.     kBadTupleDataErr            = -9092,                        /* Data in tuple is invalid */
  443.     kBadCustomIFIDErr            = -9093,                        /* Custom interface ID is invalid */
  444.     kNoIOWindowRequestedErr        = -9094,                        /* Request I/O window before calling configuration */
  445.     kNoMoreTimerClientsErr        = -9095,                        /* All timer callbacks are in use */
  446.     kNoMoreInterruptSlotsErr    = -9096,                        /* All internal Interrupt slots are in use */
  447.     kNoClientTableErr            = -9097,                        /* The client table has not be initialized yet */
  448.     kUnsupportedCardErr            = -9098,                        /* Card not supported by generic enabler*/
  449.     kNoCardEnablersFoundErr        = -9099,                        /* No Enablers were found*/
  450.     kNoEnablerForCardErr        = -9100,                        /* No Enablers were found that can support the card*/
  451.     kNoCompatibleNameErr        = -9101,                        /* There is no compatible driver name for this device*/
  452.     kClientRequestDenied        = -9102,                        /* CS Clients should return this code inorder to */
  453.                                                                 /*   deny a request-type CS Event                */
  454.     kNotReadyErr                = -9103,                        /* PC Card failed to go ready */
  455.     kTooManyIOWindowsErr        = -9104,                        /* device requested more than one I/O window */
  456.     kAlreadySavedStateErr        = -9105,                        /* The state has been saved on previous call */
  457.     kAttemptDupCardEntryErr        = -9106                            /* The Enabler was asked to create a duplicate card entry */
  458. };
  459.  
  460.  
  461. #pragma options align=reset
  462. #endif /* PRAGMA_ALIGN_SUPPORTED */
  463.  
  464. #if PRAGMA_IMPORT_SUPPORTED
  465. #pragma import off
  466. #endif
  467.  
  468. #ifdef __cplusplus
  469. }
  470. #endif
  471.  
  472. #endif /* __PCCARD__ */
  473.  
  474.